import { createRouter, createWebHashHistory } from "vue-router";
import { constantRoutes, dynamicRoutes } from "@/router/router";
// import { ElMessage } from "element-plus";
import { store } from "@/store/index";
import { Session } from "@/utils/storage";
//import { getToken } from "@/utils/auth";

import { initFrontEndControlRoutes } from "@/router/frontEnd";
import { initBackEndControlRoutes } from "@/router/backContro";

//import { NextLoading } from "@/utils/loading";
import NProgress from "nprogress";
import "nprogress/nprogress.css";

// import Layout from "@/layout";
//const whiteList = ["/login", "/auth-redirect", "/bind", "/register"];

/**
 * 定义404界面
 * @link 参考：https://next.router.vuejs.org/zh/guide/essentials/history-mode.html#netlify
 */
const pathMatch = {
  path: "/:path(.*)*",
  redirect: "/404",
};

/**
 * 路由多级嵌套数组处理成一维数组
 * @param arr 传入路由菜单数据数组
 * @returns 返回处理后的一维路由菜单数组
 */
export function formatFlatteningRoutes (arr) {
  if (arr.length <= 0) return false;
  for (let i = 0; i < arr.length; i++) {
    if (arr[i].children) {
      arr = arr.slice(0, i + 1).concat(arr[i].children, arr.slice(i + 1));
    }
  }
  return arr;
}

/**
 * 一维数组处理成多级嵌套数组（只保留二级：也就是二级以上全部处理成只有二级，keep-alive 支持二级缓存）
 * @description isKeepAlive 处理 `name` 值，进行缓存。顶级关闭，全部不缓存
 * @link 参考：https://v3.cn.vuejs.org/api/built-in-components.html#keep-alive
 * @param arr 处理后的一维路由菜单数组
 * @returns 返回将一维数组重新处理成 `定义动态路由（dynamicRoutes）` 的格式
 */
export function formatTwoStageRoutes(arr) {
  if (arr.length <= 0) return false;
  const newArr = [];
  const cacheList = [];
  arr.forEach((v) => {
    if (v.path === "/") {
      newArr.push({
        component: v.component,
        name: v.name,
        path: v.path,
        redirect: v.redirect,
        meta: v.meta,
        children: [],
      });
    } else {
      // 判断是否是动态路由（xx/:id/:name），用于 tagsView 等中使用
      // 修复：https://gitee.com/lyt-top/vue-next-admin/issues/I3YX6G
      if (v.path.indexOf("/:") > -1) {
        v.meta["isDynamic"] = true;
        v.meta["isDynamicPath"] = v.path;
      }
      newArr[0].children.push({ ...v });
      // 存 name 值，keep-alive 中 include 使用，实现路由的缓存
      // 路径：/@/layout/routerView/parent.vue
      if (newArr[0].meta.isKeepAlive && v.meta.isKeepAlive) {
        cacheList.push(v.name);
        store.dispatch("keepAliveNames/setCacheKeepAlive", cacheList);
      }
    }
  });
  return newArr;
}

/**
 * 缓存多级嵌套数组处理后的一维数组
 * @description 用于 tagsView、菜单搜索中：未过滤隐藏的(hide)
 */
export function setCacheTagsViewRoutes() {
  // 获取有权限的路由，否则 tagsView、菜单搜索中无权限的路由也将显示

  let authsRoutes = setFilterHasAuthMenu(
    dynamicRoutes,
    store.state.userInfos.userInfos.roles
  );
  // 添加到 vuex setTagsViewRoutes 中
  store.dispatch(
    "tagsViewRoutes/setTagsViewRoutes",
    formatTwoStageRoutes(formatFlatteningRoutes(authsRoutes))[0].children
  );
}

/**
 * 判断路由 `meta.auth` 中是否包含当前登录用户权限字段
 * @param auths 用户权限标识，在 userInfos（用户信息）的 authPageList（登录页登录时缓存到浏览器）数组
 * @param route 当前循环时的路由项
 * @returns 返回对比后有权限的路由项
 */
export function hasAuth(auths, route) {
  if (route.meta && route.meta.auth)
    return auths.some((auth) => route.meta.auth.includes(auth));
  else return true;
}

/**
 * 获取当前用户权限标识去比对路由表，设置递归过滤有权限的路由
 * @param routes 当前路由 children
 * @param auth 用户权限标识，在 userInfos（用户信息）的 authPageList（登录页登录时缓存到浏览器）数组
 * @returns 返回有权限的路由数组 `meta.auth` 中控制
 */
export function setFilterHasAuthMenu(routes, auth) {
  const menu = [];
  routes.forEach((route) => {
    const item = { ...route };
    if (hasAuth(auth, item)) {
      if (item.children)
        item.children = setFilterHasAuthMenu(item.children, auth);
      menu.push(item);
    }
  });
  return menu;
}

/**
 * 设置递归过滤有权限的路由到 vuex routesList 中（已处理成多级嵌套路由）及缓存多级嵌套数组处理后的一维数组
 * @description 用于左侧菜单、横向菜单的显示
 * @description 用于 tagsView、菜单搜索中：未过滤隐藏的(hide)
 */
export function setFilterMenuAndCacheTagsViewRoutes() {
  store.dispatch(
    "routesList/setRoutesList",
    setFilterHasAuthMenu(
      dynamicRoutes[0].children,
      store.state.userInfos.userInfos.roles
    )
  );
  setCacheTagsViewRoutes();
}

/**
 * 获取当前用户权限标识去比对路由表（未处理成多级嵌套路由）
 * @description 这里主要用于动态路由的添加，router.addRoute
 * @link 参考：https://next.router.vuejs.org/zh/api/#addroute
 * @param chil dynamicRoutes（/@/router/route）第一个顶级 children 的下路由集合
 * @returns 返回有当前用户权限标识的路由数组
 */
export function setFilterRoute(chil) {
  let filterRoute = [];
  chil.forEach((route) => {
    if (route.meta.auth) {
      route.meta.auth.forEach((metaAuth) => {
        store.state.userInfos.userInfos.roles.forEach((auth) => {
          if (metaAuth === auth) filterRoute.push({ ...route });
        });
      });
    } else {
      filterRoute.push({ ...route })
    }
    
  });
  return filterRoute;
}

/**
 * 获取有当前用户权限标识的路由数组，进行对原路由的替换
 * @description 替换 dynamicRoutes（/@/router/route）第一个顶级 children 的路由
 * @returns 返回替换后的路由数组
 */
export function setFilterRouteEnd () {
  let filterRouteEnd = formatTwoStageRoutes(
    formatFlatteningRoutes(dynamicRoutes)
  );

  filterRouteEnd[0].children = [
    ...setFilterRoute(filterRouteEnd[0].children),
    { ...pathMatch },
  ];
  return filterRouteEnd;
}

/**
 * 添加动态路由
 * @method router.addRoute
 * @description 此处循环为 dynamicRoutes（/@/router/route）第一个顶级 children 的路由一维数组，非多级嵌套
 * @link 参考：https://next.router.vuejs.org/zh/api/#addroute
 */
export function setAddRoute() {
  setFilterRouteEnd().forEach((route) => {
    const routeName = route.name;
    if (!router.hasRoute(routeName)) {
      router.addRoute(route);
    }
  });
}

/**
 * 删除/重置路由
 * @method router.removeRoute
 * @description 此处循环为 dynamicRoutes（/@/router/route）第一个顶级 children 的路由一维数组，非多级嵌套
 * @link 参考：https://next.router.vuejs.org/zh/api/#push
 */
export function resetRoute() {
  setFilterRouteEnd().forEach((route) => {
    const routeName = route.name;
    router.hasRoute(routeName) && router.removeRoute(routeName);
  });
}

// isRequestRoutes 为 true，则开启后端控制路由，路径：`/src/store/modules/themeConfig.ts`
//const { isRequestRoutes } = store.state.themeConfig.themeConfig;
// 前端控制路由：初始化方法，防止刷新时路由丢失
//if (!isRequestRoutes) initFrontEndControlRoutes();
/**
const constantRoutes = [
  {
    path: "/login",
    component: () => import("@/views/common/login/index.vue"),
    hidden: true,
  },
  {
    path: "/",
    component: Layout,
    redirect: "index",
    children: [
      {
        path: "index",
        component: () => import("@/views/dashboard"),
        name: "首页",
        meta: { title: "首页" },
      },
    ],
  },
  {
    path: "/about",
    name: "About",
    component: () => import("@/views/About.vue"),
  },
];
*/
const router = createRouter({
  history: createWebHashHistory(),
  routes: constantRoutes,
});

/** 
router.beforeEach((to, from, next) => {
  // NProgress.start();
  // const token = Session.get("token");
  const token = getToken();
  if (token) {
    if (to.path === "/login") {
      next({ path: "/" });
      // NProgress.done();
    } else {
      if (store.getters.roles.length === 0) {
        // 判断当前用户是否已拉取完user_info信息
        store
          .dispatch("userInfos/GetInfo")
          .then(() => {
            store.dispatch("GenerateRoutes").then((accessRoutes) => {
              // 根据roles权限生成可访问的路由表
              router.addRoutes(accessRoutes); // 动态添加可访问路由表
              next({ ...to, replace: true }); // hack方法 确保addRoutes已完成
            });
          })
          .catch((err) => {
            console.log(err);
            store.dispatch("userInfos/LogOut").then(() => {
              ElMessage.error(err);
              next({ path: "/" });
            });
          });
      } else {
        next();
      }
    }
  } else {
    // 没有token
    if (whiteList.indexOf(to.path) !== -1) {
      // 在免登录白名单，直接进入
      next();
    } else {
      next(`/login?redirect=${to.fullPath}`); // 否则全部重定向到登录页
      // NProgress.done();
    }
  }
});
*/

// isRequestRoutes 为 true，则开启后端控制路由，路径：`/src/store/modules/themeConfig.ts`
////console.log(store.state);
const { isRequestRoutes } = store.state.themeConfig.themeConfig;
//console.log("路由控制: ", isRequestRoutes);
// 前端控制路由：初始化方法，防止刷新时路由丢失
if (!isRequestRoutes) initFrontEndControlRoutes();

// 路由加载前
router.beforeEach(async(to, from, next) => {
  NProgress.configure({ showSpinner: false });
  if (to.meta.title) NProgress.start();
  //debugger;
  const token = Session.get("token");
  if (to.path === "/login" && !token) {
    next();
    //NProgress.done();
  } else {
    if (!token) {
      next(
        `/login?redirect=${to.path}&params=${JSON.stringify(
          to.query ? to.query : to.params
        )}`
      );
      Session.clear();
      //resetRoute();
      //NProgress.done();
    } else if (token && to.path === "/login") {
      next("/home");
      //NProgress.done();
    } else {
      //debugger;
      if (store.state.routesList.routesList.length === 0) {
        if (isRequestRoutes) {
          // 后端控制路由：路由数据初始化，防止刷新时丢失
          await initBackEndControlRoutes();
          // 动态添加路由：防止非首页刷新时跳转回首页的问题
          // 确保 addRoute() 时动态添加的路由已经被完全加载上去
          next({ ...to, replace: true });
        }
      } else {
        next();
      }
    }
  }
});

router.afterEach(() => {
  NProgress.done();
  //NextLoading.done();
});

export default router;
